
import os
import torch
import torchvision
import pandas as pd
import torch.nn as nn
import torch.nn.functional as F
from tqdm.notebook import tqdm
import torchvision.models as models
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from torchvision.utils import make_grid
import torchvision.transforms as transforms
from torchvision.datasets.folder import default_loader
import matplotlib.pyplot as plt
%matplotlib inline


!pip install opendatasets --upgrade --quiet # Needed to upload dataset directly from Kaggle to Colab without storing on PC


import opendatasets as od


dataset_url='https://www.kaggle.com/ikarus777/best-artworks-of-all-time'


od.download(dataset_url)

  0%|          | 0.00/2.29G [00:00<?, ?B/s]

Downloading best-artworks-of-all-time.zip to ./best-artworks-of-all-time

100%|██████████| 2.29G/2.29G [00:30<00:00, 81.6MB/s]


# Listing all artists in dataset
artists = pd.read_csv("best-artworks-of-all-time/artists.csv")

for i in artists['name']:
    print(i,end=" , ")

Amedeo Modigliani , Vasiliy Kandinskiy , Diego Rivera , Claude Monet , Rene Magritte , Salvador Dali , Edouard Manet , Andrei Rublev , Vincent van Gogh , Gustav Klimt , Hieronymus Bosch , Kazimir Malevich , Mikhail Vrubel , Pablo Picasso , Peter Paul Rubens , Pierre-Auguste Renoir , Francisco Goya , Frida Kahlo , El Greco , Albrecht Dürer , Alfred Sisley , Pieter Bruegel , Marc Chagall , Giotto di Bondone , Sandro Botticelli , Caravaggio , Leonardo da Vinci , Diego Velazquez , Henri Matisse , Jan van Eyck , Edgar Degas , Rembrandt , Titian , Henri de Toulouse-Lautrec , Gustave Courbet , Camille Pissarro , William Turner , Edvard Munch , Paul Cezanne , Eugene Delacroix , Henri Rousseau , Georges Seurat , Paul Klee , Piet Mondrian , Joan Miro , Andy Warhol , Paul Gauguin , Raphael , Michelangelo , Jackson Pollock ,


# Fixing constant size for all images
batch_size = 128
image_size = (64,64)
stats = (0.5, 0.5, 0.5), (0.5, 0.5, 0.5)


transform_ds = transforms.Compose([transforms.Resize(image_size),
#                                    transforms.RandomCrop(32, padding=2),
#                                    transforms.RandomHorizontalFlip(),
                                   transforms.ToTensor(),
                                   transforms.Normalize(*stats)
                                   ])

train_ds = torchvision.datasets.ImageFolder(root="best-artworks-of-all-time/resized",
                                     transform=transform_ds)

train_dl = DataLoader(train_ds, batch_size, shuffle=True, num_workers=3, pin_memory=True)
print(len(train_ds))

8683

/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 3 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.
  cpuset_checked))


# Checking out the ready artworks after transformations
images,_ = train_ds[874]
print(images.size())
plt.imshow(images.permute(1,2,0))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

torch.Size([3, 64, 64])

<matplotlib.image.AxesImage at 0x7ff097355490>


images,_ = train_ds[5648]
plt.imshow(images.permute(1,2,0))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

<matplotlib.image.AxesImage at 0x7ff0971944d0>


images,_ = train_ds[7120]
plt.imshow(images.permute(1,2,0))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

<matplotlib.image.AxesImage at 0x7ff09705c8d0>


def denorm(img_tensors):
    return img_tensors * stats[1][0] + stats[0][0]


def show_images(images, nmax=64):
    fig, ax = plt.subplots(figsize=(8, 8))
    ax.set_xticks([]); ax.set_yticks([])
    ax.imshow(make_grid(denorm(images.detach()[:nmax]), nrow=8).permute(1, 2, 0))

def show_batch(dl, nmax=64):
    for images, _ in dl:
        show_images(images, nmax)
        break


show_batch(train_dl) # One batch of artworks in training dataset

/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 3 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.
  cpuset_checked))


def get_default_device():
    # Pick GPU if available, else CPU
    if torch.cuda.is_available():
        return torch.device('cuda')
    else:
        return torch.device('cpu')
    
def to_device(data, device):
    # Move tensor(s) to chosen device
    if isinstance(data, (list,tuple)):
        return [to_device(x, device) for x in data]
    return data.to(device, non_blocking=True)

class DeviceDataLoader():
    # Wrap a dataloader to move data to a device
    def __init__(self, dl, device):
        self.dl = dl
        self.device = device
        
    def __iter__(self):
        # Yield a batch of data after moving it to device
        for b in self.dl: 
            yield to_device(b, self.device)

    def __len__(self):
        # Number of batches
        return len(self.dl)


device = get_default_device()
device

device(type='cuda')


train_dl = DeviceDataLoader(train_dl, device)


#DISCRIMINATOR
discriminator = nn.Sequential(
    # in: 3 x 64 x 64

    nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(64),
    nn.LeakyReLU(0.2, inplace=True),
    # out: 64 x 32 x 32

    nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(128),
    nn.LeakyReLU(0.2, inplace=True),
    # out: 128 x 16 x 16

    nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(256),
    nn.LeakyReLU(0.2, inplace=True),
    # out: 256 x 8 x 8

    nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(512),
    nn.LeakyReLU(0.2, inplace=True),
    # out: 512 x 4 x 4

    nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=0, bias=False),
    # out: 1 x 1 x 1

    nn.Flatten(),
    nn.Sigmoid())


discriminator = to_device(discriminator, device)


latent_size = 150


#GENERATOR
generator = nn.Sequential(
    # in: latent_size x 1 x 1

    nn.ConvTranspose2d(latent_size, 512, kernel_size=4, stride=1, padding=0, bias=False),
    nn.BatchNorm2d(512),
    nn.ReLU(True),
    # out: 512 x 4 x 4

    nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(256),
    nn.ReLU(True),
    # out: 256 x 8 x 8

    nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(128),
    nn.ReLU(True),
    # out: 128 x 16 x 16

    nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),
    nn.BatchNorm2d(64),
    nn.ReLU(True),
    # out: 64 x 32 x 32

    nn.ConvTranspose2d(64, 3, kernel_size=4, stride=2, padding=1, bias=False),
    nn.Tanh()
    # out: 3 x 64 x 64
)


# Fake batch of artwork for training
xb = torch.randn(batch_size, latent_size, 1, 1) # random latent tensors
fake_images = generator(xb)
print(fake_images.shape)
show_images(fake_images)

torch.Size([128, 3, 64, 64])


generator = to_device(generator, device)


def train_discriminator(real_images, opt_d):
    # Clear discriminator gradients
    opt_d.zero_grad()

    # Pass real images through discriminator
    real_preds = discriminator(real_images)
    real_targets = torch.ones(real_images.size(0), 1, device=device)
    real_loss = F.binary_cross_entropy(real_preds, real_targets)
    real_score = torch.mean(real_preds).item()
    
    # Generate fake images
    latent = torch.randn(batch_size, latent_size, 1, 1, device=device)
    fake_images = generator(latent)

    # Pass fake images through discriminator
    fake_targets = torch.zeros(fake_images.size(0), 1, device=device)
    fake_preds = discriminator(fake_images)
    fake_loss = F.binary_cross_entropy(fake_preds, fake_targets)
    fake_score = torch.mean(fake_preds).item()

    # Update discriminator weights
    loss = real_loss + fake_loss
    loss.backward()
    opt_d.step()
    return loss.item(), real_score, fake_score


def train_generator(opt_g):
    # Clear generator gradients
    opt_g.zero_grad()
    
    # Generate fake images
    latent = torch.randn(batch_size, latent_size, 1, 1, device=device)
    fake_images = generator(latent)
    
    # Try to fool the discriminator
    preds = discriminator(fake_images)
    targets = torch.ones(batch_size, 1, device=device)
    loss = F.binary_cross_entropy(preds, targets)
    
    # Update generator weights
    loss.backward()
    opt_g.step()
    
    return loss.item()


from torchvision.utils import save_image


sample_dir = 'generated'
os.makedirs(sample_dir, exist_ok=True)


def save_samples(index, latent_tensors, show=True):
    fake_images = generator(latent_tensors)
    fake_fname = 'generated-images-{0:0=4d}.png'.format(index)
    save_image(denorm(fake_images), os.path.join(sample_dir, fake_fname), nrow=8)
    print('Saving', fake_fname)
    if show:
        fig, ax = plt.subplots(figsize=(8, 8))
        ax.set_xticks([]); ax.set_yticks([])
        ax.imshow(make_grid(fake_images.cpu().detach(), nrow=8).permute(1, 2, 0))


fixed_latent = torch.randn(64, latent_size, 1, 1, device=device)


save_samples(0, fixed_latent)

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Saving generated-images-0000.png


from tqdm.notebook import tqdm
import torch.nn.functional as F


def fit(epochs, lr, start_idx=1):
    torch.cuda.empty_cache()
    
    # Losses & scores
    losses_g = []
    losses_d = []
    real_scores = []
    fake_scores = []
    
    # Create optimizers
    opt_d = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))
    opt_g = torch.optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
    
    for epoch in range(epochs):
        for real_images, _ in tqdm(train_dl):
            # Train discriminator
            loss_d, real_score, fake_score = train_discriminator(real_images, opt_d)
            # Train generator
            loss_g = train_generator(opt_g)
            
        # Record losses & scores
        losses_g.append(loss_g)
        losses_d.append(loss_d)
        real_scores.append(real_score)
        fake_scores.append(fake_score)
        
        # Log losses & scores (last batch)
        print("Epoch [{}/{}], loss_g: {:.4f}, loss_d: {:.4f}, real_score: {:.4f}, fake_score: {:.4f}".format(
            epoch+1, epochs, loss_g, loss_d, real_score, fake_score))
    
        # Save generated images
        save_samples(epoch+start_idx, fixed_latent, show=False)
    
    return losses_g, losses_d, real_scores, fake_scores


lr = 0.001 # Learning rate
epochs = 150 # Time frame


history = fit(epochs,lr) # Training the machine to generate realistic artwork

/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 3 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.
  cpuset_checked))

Epoch [1/150], loss_g: 3.9710, loss_d: 0.1516, real_score: 0.9295, fake_score: 0.0695
Saving generated-images-0001.png

Epoch [2/150], loss_g: 2.5820, loss_d: 0.7019, real_score: 0.5927, fake_score: 0.0549
Saving generated-images-0002.png

Epoch [3/150], loss_g: 1.5703, loss_d: 1.0796, real_score: 0.5785, fake_score: 0.3478
Saving generated-images-0003.png

Epoch [4/150], loss_g: 2.0581, loss_d: 1.1896, real_score: 0.6421, fake_score: 0.4836
Saving generated-images-0004.png

Epoch [5/150], loss_g: 1.8414, loss_d: 0.9864, real_score: 0.7161, fake_score: 0.4407
Saving generated-images-0005.png

Epoch [6/150], loss_g: 2.5509, loss_d: 3.4502, real_score: 0.0922, fake_score: 0.0151
Saving generated-images-0006.png

Epoch [7/150], loss_g: 1.6868, loss_d: 0.9463, real_score: 0.4764, fake_score: 0.1090
Saving generated-images-0007.png

Epoch [8/150], loss_g: 1.6411, loss_d: 0.8523, real_score: 0.5831, fake_score: 0.2242
Saving generated-images-0008.png

Epoch [9/150], loss_g: 3.4504, loss_d: 0.9672, real_score: 0.7877, fake_score: 0.4644
Saving generated-images-0009.png


from IPython.display import Image # Now we check machine's output from start to end of the training


Image('./generated/generated-images-0013.png')


Image('./generated/generated-images-0037.png')


Image('./generated/generated-images-0072.png')


Image('./generated/generated-images-0103.png')


Image('./generated/generated-images-0138.png')


Image('./generated/generated-images-0150.png') # Final generated batch of artworks


losses_g, losses_d, real_scores, fake_scores = history


# Save the model checkpoints 
torch.save(generator.state_dict(), 'G.ckpt')
torch.save(discriminator.state_dict(), 'D.ckpt')


plt.plot(losses_d, '-')
plt.plot(losses_g, '-')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['Discriminator', 'Generator'])
plt.title('Losses');


plt.plot(real_scores, '-')
plt.plot(fake_scores, '-')
plt.xlabel('epoch')
plt.ylabel('score')
plt.legend(['Real', 'Fake'])
plt.title('Scores');

Using generative adversarial networks (deep learning) to generate artwork created by AI.¶